import { reactive, ref, onMounted, onUnmounted, watch, type Ref } from 'vue'
import { debounce } from 'lodash'
import { storeToRefs } from 'pinia'
import { useAuthStore } from '@/store/auth'

// 定义基础搜索参数的类型
export interface BaseSearchParams {
  pageNumber: number
  pageSize: number
  pages: number
  status: string
  [key: string]: any
}


// 定义列表数据 hook 的配置选项
export interface UseListDataOptions<T> {
  // 获取列表数据的函数
  fetchData: (params: BaseSearchParams & T) => Promise<{
    data: {
      records: any[]
      current: number
      size: number
      pages: number
    }
  }>
  // 搜索参数的初始值
  initialSearchParams: T
  // 是否启用定时刷新（默认不启用）
  enableAutoRefresh?: boolean
  // 定时刷新的间隔时间（毫秒，默认 60000）
  refreshInterval?: number
  // 是否监听全局参数变化（默认启用）
  watchGlobalParams?: boolean
  // 防抖时间（毫秒，默认 500）
  debounceTime?: number
}

/**
 * 通用的列表数据 hook
 * @param options 配置选项
 * @returns 列表数据相关的状态和方法
 */
export function useListData<T extends object> (options: UseListDataOptions<T>) {
  const {
    fetchData,
    initialSearchParams,
    enableAutoRefresh = false,
    refreshInterval = 60000,
    watchGlobalParams = true,
    debounceTime = 500
  } = options

  const baseSearch = reactive<BaseSearchParams>({
    pageNumber: 1,
    pageSize: 20,
    pages: Infinity,
    status: '-- 加载中 --'
  })

  // 搜索参数
  const search = reactive<T>({ ...initialSearchParams })

  // 列表数据
  const listData = ref<any[]>([])

  // 定时器引用
  const interval = ref<number | null>(null)

  // 加载状态
  const loading = ref(false)

  /**
   * 获取列表数据
   * 使用防抖处理，避免频繁请求
   */
  const getListData = debounce(async (clear = false) => {
    baseSearch.status = '-- 加载中 --'
    loading.value = true
    try {
      const { data } = await fetchData({ ...baseSearch, ...search } as BaseSearchParams & T)
      if (data.records.length === 0) {
        baseSearch.status = '-- 暂无数据 --'
        return
      } else if (baseSearch.pageNumber >= data.pages) {
        baseSearch.status = '-- 没有更多了 --'
      }
      if (clear) {
        listData.value = []
      }
      listData.value = listData.value.concat(data.records)
      baseSearch.pageNumber = data.current
      baseSearch.pageSize = data.size
      baseSearch.pages = data.pages
    } catch (error) {
      console.error('获取列表数据失败:', error)
    } finally {
      loading.value = false
    }
  }, debounceTime)

  /**
   * 滚动加载更多数据
   */
  function scrollLoad () {
    if (baseSearch.pageNumber >= baseSearch.pages) {
      return
    }
    baseSearch.pageNumber++
    getListData()
  }

  /**
   * 重置列表数据
   */
  async function resetList () {
    baseSearch.pageNumber = 1
    await getListData(true)
  }

  /**
   * 组件挂载时初始化数据
   */
  onMounted(() => {
    // 设置定时器，定时刷新数据
    if (enableAutoRefresh) {
      interval.value = window.setInterval(async () => {
        await resetList()
      }, refreshInterval)
    }

    // 监听全局参数变化事件
    if (watchGlobalParams) {
      watch(() => globalParams.value, () => {
        resetList()
      }, { immediate: true, deep: true })
    }
  })

  const authStore = useAuthStore()
  const { globalParams } = storeToRefs(authStore)

  /**
   * 组件卸载时清理资源
   */
  onUnmounted(() => {
    if (interval.value) {
      clearInterval(interval.value)
    }
  })

  // 监听搜索参数变化，自动刷新数据
  watch(
    search,
    () => {
      resetList()
    },
    { immediate: true, deep: true }
  )

  return {
    search,
    baseSearch,
    listData,
    loading,
    scrollLoad,
    resetList,
    getListData
  }
} 